home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #2 / Ham Radio 2000 - Volume 2.iso / HAMV2 / TCP_IP / TNOS230S / PPPCMD.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-23  |  12.6 KB  |  530 lines
  1. /*
  2.  *  PPPCMD.C    -- PPP related user commands
  3.  *
  4.  *    This implementation of PPP is declared to be in the public domain.
  5.  *
  6.  *    Jan 91    Bill_Simpson@um.cc.umich.edu
  7.  *        Computer Systems Consulting Services
  8.  *
  9.  *    Acknowledgements and correction history may be found in PPP.C
  10.  */
  11.  
  12. #include "global.h"
  13. #include "mbuf.h"
  14. #include "iface.h"
  15. #include "pktdrvr.h"
  16. #include "ppp.h"
  17. #include "pppfsm.h"
  18. #include "ppplcp.h"
  19. #include "ppppap.h"
  20. #include "pppipcp.h"
  21. #include "cmdparse.h"
  22.  
  23. #if !defined(_lint)
  24. static char rcsid[] OPTIONAL = "$Id: pppcmd.c,v 1.15 1996/12/23 20:37:36 root Exp root $";
  25. #endif
  26.  
  27.  
  28. #ifdef PPP
  29.  
  30. static struct iface *ppp_lookup (char *ifname);
  31. static int doppp_quick (int argc, char *argv[], void *p);
  32. static int doppp_trace (int argc, char *argv[], void *p);
  33. static int spot (int16 work, int16 want, int16 will, int16 mask);
  34. static void genstat (struct ppp_s * ppp_p);
  35. static void lcpstat (struct fsm_s * fsm_p);
  36. static void papstat (struct fsm_s * fsm_p);
  37. static void ipcpstat (struct fsm_s * fsm_p);
  38. static int dotry_nak (int argc, char *argv[], void *p);
  39. static int dotry_req (int argc, char *argv[], void *p);
  40. static int dotry_terminate (int argc, char *argv[], void *p);
  41.  
  42.  
  43.  
  44. /* "ppp" subcommands */
  45. static struct cmds Pppcmds[] =
  46. {
  47.     { "ipcp",    doppp_ipcp,    0, 0, NULLCHAR },
  48.     { "lcp",    doppp_lcp,    0, 0, NULLCHAR },
  49.     { "pap",    doppp_pap,    0, 0, NULLCHAR },
  50.     { "quick",    doppp_quick,    0, 0, NULLCHAR },
  51.     { "trace",    doppp_trace,    0, 0, NULLCHAR },
  52.     { NULLCHAR,    NULL,        0, 0, NULLCHAR }
  53. };
  54.  
  55.  
  56. /* { "ppp <iface> <ncp> try" subcommands */
  57. static struct cmds PppTrycmds[] =
  58. {
  59.     { "configure",    dotry_req,    0, 0, NULLCHAR },
  60.     { "failure",    dotry_nak,    0, 0, NULLCHAR },
  61.     { "terminate",    dotry_terminate,0, 0, NULLCHAR },
  62.     { NULLCHAR,    NULL,        0, 0, NULLCHAR }
  63. };
  64.  
  65.  
  66. static const char *PPPStatus[] =
  67. {
  68.     "Physical Line Dead",
  69.     "Establishment Phase",
  70.     "Authentication Phase",
  71.     "Network Protocol Phase",
  72.     "Termination Phase"
  73. };
  74.  
  75.  
  76. static const char *NCPStatus[] =
  77. {
  78.     "Closed",
  79.     "Listening -- waiting for remote host to attempt open",
  80.     "Starting configuration exchange",
  81.     "Remote host accepted our request; waiting for remote request",
  82.     "We accepted remote request; waiting for reply to our request",
  83.     "Opened",
  84.     "Terminate request sent to remote host"
  85. };
  86.  
  87.  
  88. #ifdef CATALOG
  89. #include "catalog.h"
  90.  
  91. #define CAT pppcmd_catalog
  92.  
  93. #define ifaceunk    __STR(0)
  94. #define notPPP        __STR(1)
  95. #define syntaxPPP    __STR(2)
  96. #define PPPtracing    __STR(3)
  97.  
  98. #else /* CATALOG */
  99.  
  100. static const char ifaceunk[] = "%s: Interface unknown\n";
  101. static const char notPPP[] = "%s: not a PPP interface\n";
  102. static const char syntaxPPP[] = "ppp <iface> required\n";
  103. static const char PPPtracing[] = "PPP tracing";
  104.  
  105. #endif /* CATALOG */
  106.  
  107. static const char stat1[] = "%10lu In,  %10lu Flags,%6u ME, %6u FE, %6u CSE, %6u other\n";
  108. static const char stat2[] = "\t\t%6u Lcp,%6u Pap,%6u IPcp,%6u Unknown\n";
  109. static const char stat3[] = "%10lu Out, %10lu Flags,%6u ME, %6u Fail\n";
  110. static const char stat4[] = "\t\t%6u Lcp,%6u Pap,%6u IPcp\n";
  111. static const char PAPstr[] = "PAP %s\n";
  112. static const char LCPstr[] = "LCP %s\n";
  113. static const char header[] = "\t\t MRU\t ACCM\t\t AP\t PFC  ACFC Magic\n\tLocal:\t";
  114. static const char yes[] = "Yes ";
  115. static const char no[] = "No  ";
  116. static const char unused[] = "unused\n";
  117. static const char none[] = "None\t";
  118. static const char none2[] = "none";
  119. static const char papmessage[] = "\tMessage: '%s'\n";
  120. static const char IPCPstr[] = "IPCP %s\n";
  121. static const char localaddr[] = "\tlocal IP address: %s";
  122. static const char remoteaddr[] = "  remote IP address: %s\n";
  123. static const char ipcpstatstr[] = "   %s\tTCP header compression enabled: slots = %d, flag = 0x%02x\n";
  124. static const char badval[] = "Value %s (%d) must be > 0\n";
  125. static const char intstr[] = "%d\n";
  126. static const char longstr[] = "%d\n";
  127. static const char openfor[] = "\t(open for %s)";
  128. static const char hexstr[] = "0x%08lx%c";
  129. static const char hexstr2[] = "0x%04x\t";
  130. static const char paptab[] = "Pap\t";
  131. static const char remotestr[] = "\tRemote:\t";
  132. static const char int4str[] = "%4d\t";
  133.  
  134.  
  135. int PPPtrace;
  136. struct iface *PPPiface;        /* iface for trace */
  137.  
  138.  
  139. /****************************************************************************/
  140.  
  141. static struct iface *
  142. ppp_lookup (char *ifname)
  143. {
  144. register struct iface *ifp;
  145.  
  146.     if ((ifp = if_lookup (ifname)) == NULLIF) {
  147.         tprintf (ifaceunk, ifname);
  148.         return (NULLIF);
  149.     }
  150.     if (ifp->type != CL_PPP) {
  151.         tprintf (notPPP, ifp->name);
  152.         return (NULLIF);
  153.     }
  154.     return (ifp);
  155. }
  156.  
  157.  
  158.  
  159. /****************************************************************************/
  160.  
  161. int
  162. doppp_commands (int argc, char *argv[], void *p OPTIONAL)
  163. {
  164. register struct iface *ifp;
  165.  
  166.     if (argc < 2) {
  167.         tputs (syntaxPPP);
  168.         return -1;
  169.     }
  170.     if ((ifp = ppp_lookup (argv[1])) == NULLIF)
  171.         return -1;
  172.  
  173.     if (argc == 2) {
  174.         ppp_show (ifp);
  175.         return 0;
  176.     }
  177.     return subcmd (Pppcmds, argc - 1, &argv[1], ifp);
  178. }
  179.  
  180.  
  181.  
  182. /* Close connection on PPP interface */
  183. int
  184. doppp_close (int argc OPTIONAL, char *argv[] OPTIONAL, void *p)
  185. {
  186. register struct fsm_s *fsm_p = p;
  187.  
  188.     fsm_p->flags &= ~(FSM_ACTIVE | FSM_PASSIVE);
  189.  
  190.     fsm_close (fsm_p);
  191.     return 0;
  192. }
  193.  
  194.  
  195.  
  196. int
  197. doppp_passive (int argc OPTIONAL, char *argv[] OPTIONAL, void *p)
  198. {
  199. register struct fsm_s *fsm_p = p;
  200.  
  201.     fsm_p->flags &= ~FSM_ACTIVE;
  202.     fsm_p->flags |= FSM_PASSIVE;
  203.  
  204.     fsm_start (fsm_p);
  205.     return 0;
  206. }
  207.  
  208.  
  209.  
  210. int
  211. doppp_active (int argc OPTIONAL, char *argv[] OPTIONAL, void *p)
  212. {
  213. register struct fsm_s *fsm_p = p;
  214.  
  215.     fsm_p->flags &= ~FSM_PASSIVE;
  216.     fsm_p->flags |= FSM_ACTIVE;
  217.  
  218.     if (fsm_p->state < fsmLISTEN)
  219.         fsm_p->state = fsmLISTEN;
  220.     return 0;
  221. }
  222.  
  223.  
  224.  
  225. static int
  226. doppp_quick (int argc OPTIONAL, char *argv[] OPTIONAL, void *p)
  227. {
  228. register struct iface *ifp = p;
  229. register struct ppp_s *ppp_p = ifp->edv;
  230. struct lcp_s *lcp_p = ppp_p->fsm[Lcp].pdv;
  231. struct ipcp_s *ipcp_p = ppp_p->fsm[IPcp].pdv;
  232.  
  233.     lcp_p->local.want.accm = 0L;
  234.     lcp_p->local.want.negotiate |= LCP_N_ACCM;
  235.     lcp_p->local.want.magic_number += (uint32) &lcp_p->local.want.magic_number;
  236.     lcp_p->local.want.negotiate |= LCP_N_MAGIC;
  237.     lcp_p->local.want.negotiate |= LCP_N_ACFC;
  238.     lcp_p->local.want.negotiate |= LCP_N_PFC;
  239.  
  240.     ipcp_p->local.want.compression = PPP_COMPR_PROTOCOL;
  241.     ipcp_p->local.want.slots = 16;
  242.     ipcp_p->local.want.slot_compress = 1;
  243.     ipcp_p->local.want.negotiate |= IPCP_N_COMPRESS;
  244.     (void) doppp_active (0, NULL, &(ppp_p->fsm[IPcp]));
  245.  
  246.     return 0;
  247. }
  248.  
  249.  
  250.  
  251. /****************************************************************************/
  252.  
  253. void
  254. ppp_show (struct iface *ifp)
  255. {
  256. register struct ppp_s *ppp_p = ifp->edv;
  257.  
  258.     genstat (ppp_p);
  259.     if (ppp_p->fsm[Lcp].pdv != NULL)
  260.         lcpstat (&(ppp_p->fsm[Lcp]));
  261.     if (ppp_p->fsm[Pap].pdv != NULL)
  262.         papstat (&(ppp_p->fsm[Pap]));
  263.     if (ppp_p->fsm[IPcp].pdv != NULL)
  264.         ipcpstat (&(ppp_p->fsm[IPcp]));
  265. }
  266.  
  267.  
  268.  
  269. static void
  270. genstat (register struct ppp_s *ppp_p)
  271. {
  272.  
  273.     tputs (PPPStatus[ppp_p->phase]);
  274.  
  275.     if (ppp_p->phase == pppREADY)
  276.         tprintf (openfor, tformat (secclock () - ppp_p->upsince));
  277.  
  278.     tputc ('\n');
  279.  
  280.     tprintf (stat1, ppp_p->InRxOctetCount, ppp_p->InOpenFlag, ppp_p->InMemory,
  281.          ppp_p->InFrame, ppp_p->InChecksum, ppp_p->InError);
  282.     tprintf (stat2, ppp_p->InNCP[Lcp], ppp_p->InNCP[Pap],
  283.          ppp_p->InNCP[IPcp], ppp_p->InUnknown);
  284.     tprintf (stat3, ppp_p->OutTxOctetCount, ppp_p->OutOpenFlag,
  285.          ppp_p->OutMemory, ppp_p->OutError);
  286.     tprintf (stat4, ppp_p->OutNCP[Lcp], ppp_p->OutNCP[Pap], ppp_p->OutNCP[IPcp]);
  287. }
  288.  
  289.  
  290.  
  291. static int
  292. spot (int16 work, int16 want, int16 will, int16 mask)
  293. {
  294.     char blot = ' ';
  295.     int result = (work & mask);
  296.  
  297.     if (!(will & mask))
  298.         blot = '*';
  299.     else if ((want ^ work) & mask)
  300.         blot = (result ? '+' : '-');
  301.  
  302.     tputc (uchar (blot));
  303.     return result;
  304. }
  305.  
  306.  
  307.  
  308. static void
  309. lcpstat (struct fsm_s *fsm_p)
  310. {
  311. struct lcp_s *lcp_p = fsm_p->pdv;
  312. struct lcp_value_s *localp = &(lcp_p->local.work);
  313. int16 localwork = lcp_p->local.work.negotiate;
  314. int16 localwant = lcp_p->local.want.negotiate;
  315. int16 localwill = lcp_p->local.will_negotiate;
  316. struct lcp_value_s *remotep = &(lcp_p->remote.work);
  317. int16 remotework = lcp_p->remote.work.negotiate;
  318. int16 remotewant = lcp_p->remote.want.negotiate;
  319. int16 remotewill = lcp_p->remote.will_negotiate;
  320.  
  321.     tprintf (LCPstr, NCPStatus[fsm_p->state]);
  322.  
  323.     tputs (header);
  324.  
  325.     /*lint -esym(534,spot) */
  326.     spot (localwork, localwant, localwill, LCP_N_MRU);
  327.     tprintf (int4str, localp->mru);
  328.  
  329.     spot (localwork, localwant, localwill, LCP_N_ACCM);
  330.     tprintf (hexstr, localp->accm, '\t');
  331.  
  332.     if (spot (localwork, localwant, localwill, LCP_N_AUTHENT)) {
  333.         switch (localp->authentication) {
  334.             case PPP_PAP_PROTOCOL:
  335.                 tputs (paptab);
  336.                 break;
  337.             default:
  338.                 tprintf (hexstr2, localp->authentication);
  339.                 break;
  340.         }
  341.     } else
  342.         tputs (none);
  343.  
  344.     tprintf (spot (localwork, localwant, localwill, LCP_N_PFC) ? yes : no);
  345.     tprintf (spot (localwork, localwant, localwill, LCP_N_ACFC) ? yes : no);
  346.  
  347.     spot (localwork, localwant, localwill, LCP_N_MAGIC);
  348.     if (localp->magic_number != 0L)
  349.         tprintf (hexstr, localp->magic_number, '\n');
  350.     else
  351.         tputs (unused);
  352.  
  353.     tputs (remotestr);
  354.  
  355.     spot (remotework, remotewant, remotewill, LCP_N_MRU);
  356.     tprintf (int4str, remotep->mru);
  357.  
  358.     spot (remotework, remotewant, remotewill, LCP_N_ACCM);
  359.     tprintf (hexstr, remotep->accm, '\t');
  360.  
  361.     if (spot (remotework, remotewant, remotewill, LCP_N_AUTHENT)) {
  362.         switch (remotep->authentication) {
  363.             case PPP_PAP_PROTOCOL:
  364.                 tputs (paptab);
  365.                 break;
  366.             default:
  367.                 tprintf (hexstr2, remotep->authentication);
  368.                 break;
  369.         }
  370.     } else
  371.         tputs (none);
  372.  
  373.     tprintf (spot (remotework, remotewant, remotewill, LCP_N_PFC) ? yes : no);
  374.     tprintf (spot (remotework, remotewant, remotewill, LCP_N_ACFC) ? yes : no);
  375.  
  376.     spot (remotework, remotewant, remotewill, LCP_N_MAGIC);
  377.     if (remotep->magic_number != 0L)
  378.         tprintf (hexstr, remotep->magic_number, '\n');
  379.     else
  380.         tputs (unused);
  381. }
  382.  
  383.  
  384.  
  385. static void
  386. papstat (struct fsm_s *fsm_p)
  387. {
  388. struct pap_s *pap_p = fsm_p->pdv;
  389.  
  390.     tprintf (PAPstr, NCPStatus[fsm_p->state]);
  391.     tprintf (papmessage, (pap_p->message == NULL) ? none2 : pap_p->message);
  392. }
  393.  
  394.  
  395.  
  396. static void
  397. ipcpstat (struct fsm_s *fsm_p)
  398. {
  399. struct ipcp_s *ipcp_p = fsm_p->pdv;
  400. struct ipcp_value_s *localp = &(ipcp_p->local.work);
  401. int16 localwork = ipcp_p->local.work.negotiate;
  402. struct ipcp_value_s *remotep = &(ipcp_p->remote.work);
  403. int16 remotework = ipcp_p->remote.work.negotiate;
  404.  
  405.     tprintf (IPCPstr, NCPStatus[fsm_p->state]);
  406.     tprintf (localaddr, inet_ntoa (localp->address));
  407.     tprintf (remoteaddr, inet_ntoa (localp->other));
  408.  
  409.     if (localwork & IPCP_N_COMPRESS) {
  410.         tprintf (ipcpstatstr, " In", localp->slots, localp->slot_compress);
  411.         slhc_i_status (ipcp_p->slhcp);
  412.     }
  413.     if (remotework & IPCP_N_COMPRESS) {
  414.         tprintf (ipcpstatstr, "Out", remotep->slots, remotep->slot_compress);
  415.         slhc_o_status (ipcp_p->slhcp);
  416.     }
  417. }
  418.  
  419.  
  420.  
  421. /****************************************************************************/
  422. /* Set timeout interval when waiting for response from remote peer */
  423. int
  424. doppp_timeout (int argc, char *argv[], void *p)
  425. {
  426. struct fsm_s *fsm_p = p;
  427. struct timer *t = &(fsm_p->timer);
  428.  
  429.     if (argc < 2)
  430.         tprintf (longstr, dur_timer (t) / 1000L);
  431.     else {
  432.         int x = (int) strtol (argv[1], NULLCHARP, 0);
  433.  
  434.         if (x <= 0) {
  435.             tprintf (badval, argv[1], x);
  436.             return -1;
  437.         } else
  438.             set_timer (t, x * 1000L);
  439.     }
  440.     return 0;
  441. }
  442.  
  443.  
  444.  
  445. int
  446. doppp_try (int argc, char *argv[], void *p)
  447. {
  448.     return subcmd (PppTrycmds, argc, argv, p);
  449. }
  450.  
  451.  
  452.  
  453. static int
  454. dotry_nak (int argc, char *argv[], void *p)
  455. {
  456. struct fsm_s *fsm_p = p;
  457.  
  458.     if (argc < 2)
  459.         tprintf (intstr, fsm_p->try_nak);
  460.     else {
  461.         int x = (int) strtol (argv[1], NULLCHARP, 0);
  462.  
  463.         if (x <= 0) {
  464.             tprintf (badval, argv[1], x);
  465.             return -1;
  466.         } else
  467.             fsm_p->try_nak = uchar (x);
  468.     }
  469.     return 0;
  470. }
  471.  
  472.  
  473.  
  474. static int
  475. dotry_req (int argc, char *argv[], void *p)
  476. {
  477. struct fsm_s *fsm_p = p;
  478.  
  479.     if (argc < 2)
  480.         tprintf (intstr, fsm_p->try_req);
  481.     else {
  482.         int x = (int) strtol (argv[1], NULLCHARP, 0);
  483.  
  484.         if (x <= 0) {
  485.             tprintf (badval, argv[1], x);
  486.             return -1;
  487.         } else
  488.             fsm_p->try_req = uchar (x);
  489.     }
  490.     return 0;
  491. }
  492.  
  493.  
  494.  
  495. static int
  496. dotry_terminate (int argc, char *argv[], void *p)
  497. {
  498. struct fsm_s *fsm_p = p;
  499.  
  500.     if (argc < 2)
  501.         tprintf (intstr, fsm_p->try_terminate);
  502.     else {
  503.         int x = (int) strtol (argv[1], NULLCHARP, 0);
  504.  
  505.         if (x <= 0) {
  506.             tprintf (badval, argv[1], x);
  507.             return -1;
  508.         } else
  509.             fsm_p->try_terminate = uchar (x);
  510.     }
  511.     return 0;
  512. }
  513.  
  514.  
  515.  
  516. static int
  517. doppp_trace (int argc, char *argv[], void *p)
  518. {
  519. register struct iface *ifp = p;
  520. register struct ppp_s *ppp_p = ifp->edv;
  521. int tracing = ppp_p->trace;
  522. int result = setint (&tracing, PPPtracing, argc, argv);
  523.  
  524.     ppp_p->trace = uchar (tracing);
  525.     return result;
  526. }
  527.  
  528.  
  529. #endif /* PPP */
  530.